/**
 * FileName: ObjectOrder Author:   baoy Date:     2018/10/12 13:28 Description:
 */
package com.baoy.xxx.guava.order;

import com.alibaba.fastjson.JSON;
import com.google.common.base.Function;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;
import com.google.common.primitives.Ints;
import java.io.Serializable;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.annotation.Nullable;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ObjectOrder {

    static List l = Ints.asList(4, 1, 2, 3);

    public static void main(String[] args) {
        test1();
    }


    private static void test1() {
        //对可排序类型做自然排序，如数字按大小，日期按先后排序
        List sortl = Ordering.natural().sortedCopy(l);
        //按对象的字符串形式做字典排序
        Ordering.usingToString();
        //自定义排序器 - 比较字符串长度
        Ordering<String> byLengthOrdering = new Ordering<String>() {
            public int compare(String left, String right) {
                return Ints.compare(left.length(), right.length());
            }
        };

        //排序器能够支持链式调用
        Ordering.natural()
                //获取语义相反的排序器
                .reverse()
                //使用当前排序器，但额外把null值排到最前面
                .nullsFirst()
                //使用当前排序器，但额外把null值排到最后面
                .nullsLast()
                //合成另一个比较器，以处理当前排序器中的相等情况。
                .compound(new Comparator<Integer>() {
                    @Override
                    public int compare(Integer i, Integer j) {
                        return 0;
                    }
                })
                //基于处理类型T的排序器，返回该类型的可迭代对象Iterable<T>的排序器
                .lexicographical();
        //对集合中元素调用Function，再按返回值用当前排序器排序
        class Foo {

            @Nullable
            String sortedBy;

            int notSortedBy;
        }
        Ordering<Foo> ordering = Ordering.natural().nullsFirst()
                .onResultOf(new Function<Foo, String>() {
                    public String apply(Foo foo) {
                        return foo.sortedBy;
                    }
                });
        //以下是具体排序方法
        //获取可迭代对象中最大的k个元素。
        Ordering.natural().greatestOf(l, 3);
        //判断可迭代对象是否已按排序器排序：允许有排序值相等的元素。
        Ordering.natural().isOrdered(l);
        //进行排序 并把排序结果copy成另一个集合
        List sortedl = Ordering.natural().sortedCopy(l);
        //返回两个参数中最小的那个。如果相等，则返回第一个参数。
        Ordering.natural().min(1, 2);
        //返回多个参数中最小的那个。如果有超过一个参数都最小，则返回第一个最小的参数。
        Ordering.natural().min(1, 2, 3, 4);
        //返回迭代器中最小的元素。如果可迭代对象中没有元素，则抛出NoSuchElementException。
        Ordering.natural().min(l);
        //同理max
        Ordering.natural().max(1, 2);
    }

    private static void test2() {
        List<User> list = Lists.newArrayList();
        User u1 = new User(1, "Tom", 25);
        User u2 = new User(2, "Wind", 30);
        User u3 = new User(3, "William", 28);
        list.add(u1);
        list.add(u2);
        list.add(u3);
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @ToString
    public static class User implements Serializable, Comparator<User> {

        private int id;
        private String name;
        private int age;

        @Override
        public int compare(User o1, User o2) {
            return Ints.compare(o1.getAge(), o2.getAge());
        }

    }
}
